home *** CD-ROM | disk | FTP | other *** search
/ The Arsenal Files 4 / The Arsenal Files 4 (Arsenal Computer).ISO / ham / sattrk31.tgz / sattrack-3.1.tar / SatTrack / src / xdemo / xdemo.c
C/C++ Source or Header  |  1995-03-16  |  45KB  |  1,305 lines
  1. /******************************************************************************/
  2. /*                                                                            */
  3. /*  Title       : xdemo.c                                                     */
  4. /*  Author      : Manfred Bester                                              */
  5. /*  Date        : 01Nov94                                                     */
  6. /*  Last change : 15Mar95                                                     */
  7. /*                                                                            */
  8. /*  Synopsis    : SatTrack color world map demo program.                      */
  9. /*                                                                            */
  10. /*                                                                            */
  11. /*  SatTrack is Copyright (c) 1992, 1993, 1994, 1995 by Manfred Bester.       */
  12. /*  All Rights Reserved.                                                      */
  13. /*                                                                            */
  14. /*  Permission to use, copy, and distribute SatTrack and its documentation    */
  15. /*  in its entirety for educational, research and non-profit purposes,        */
  16. /*  without fee, and without a written agreement is hereby granted, provided  */
  17. /*  that the above copyright notice and the following three paragraphs appear */
  18. /*  in all copies. SatTrack may be modified for personal purposes, but        */
  19. /*  modified versions may NOT be distributed without prior consent of the     */
  20. /*  author.                                                                   */
  21. /*                                                                            */
  22. /*  Permission to incorporate this software into commercial products may be   */
  23. /*  obtained from the author, Dr. Manfred Bester, 1636 M. L. King Jr. Way,    */
  24. /*  Berkeley, CA 94709, USA. Note that distributing SatTrack 'bundled' in     */
  25. /*  with ANY product is considered to be a 'commercial purpose'.              */
  26. /*                                                                            */
  27. /*  IN NO EVENT SHALL THE AUTHOR BE LIABLE TO ANY PARTY FOR DIRECT, INDIRECT, */
  28. /*  SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OF   */
  29. /*  THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF THE AUTHOR HAS BEEN ADVISED  */
  30. /*  OF THE POSSIBILITY OF SUCH DAMAGE.                                        */
  31. /*                                                                            */
  32. /*  THE AUTHOR SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING, BUT NOT      */
  33. /*  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A   */
  34. /*  PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON AN "AS IS"      */
  35. /*  BASIS, AND THE AUTHOR HAS NO OBLIGATIONS TO PROVIDE MAINTENANCE, SUPPORT, */
  36. /*  UPDATES, ENHANCEMENTS, OR MODIFICATIONS.                                  */
  37. /*                                                                            */
  38. /******************************************************************************/
  39.  
  40. #include <stdio.h>
  41. #include <math.h>
  42. #include <string.h>
  43.  
  44. #include <X11/Intrinsic.h>
  45. #include <X11/Shell.h>
  46. #include <X11/StringDefs.h>
  47. #include <X11/Xlib.h>
  48.  
  49. #include "satstrings.h"
  50. #include "sattrack.h"
  51. #include "mir.h"
  52. #include "shuttle.h"
  53. #include "world.xbm"
  54.  
  55. /******************************************************************************/
  56. /*                                                                            */
  57. /* definitions                                                                */
  58. /*                                                                            */
  59. /******************************************************************************/
  60.  
  61. #define MAPWIDTH      (unsigned int) world_width              /* [pixels]     */
  62. #define MAPHEIGHT     (unsigned int) world_height             /* [pixels]     */
  63. #define MAPTYPE       (unsigned int) world_type               /* 1 or 2       */
  64. #define MAPWIDTHD     (double) world_widthd                   /* [deg]        */
  65. #define MAPHEIGHTD    (double) world_heightd                  /* [deg]        */
  66.  
  67. #define GRIDSCALEX    ((double) MAPWIDTH  / MAPWIDTHD)        /* [pixels/deg] */
  68. #define GRIDSCALEY    ((double) MAPHEIGHT / MAPHEIGHTD)       /* [pixels/deg] */
  69.  
  70. #define MARGINTOP     (unsigned int) 20
  71. #define MARGINBOT     (unsigned int) 20
  72. #define MARGINLFT     (unsigned int) 10
  73. #define MARGINRGT     (unsigned int) 10
  74.  
  75. #define WINWIDTH      (unsigned int) (MAPWIDTH  + MARGINLFT + MARGINRGT)
  76. #define WINHEIGHT     (unsigned int) (MAPHEIGHT + MARGINTOP + MARGINBOT)
  77. #define HEADERROW     (unsigned int) (MARGINTOP - 5)
  78. #define FOOTERROW     (unsigned int) (MARGINTOP + MAPHEIGHT + MARGINBOT - 5)
  79.  
  80. /******************************************************************************/
  81. /*                                                                            */
  82. /* structures                                                                 */
  83. /*                                                                            */
  84. /******************************************************************************/
  85.  
  86. typedef struct {
  87.     double lng, lat;
  88.     } groundTrackType;
  89.  
  90. groundTrackType groundTrack[NSEGSGT];
  91.  
  92. /******************************************************************************/
  93. /*                                                                            */
  94. /* X Window stuff and other global definitions                                */
  95. /*                                                                            */
  96. /******************************************************************************/
  97.  
  98. Display       *theDisplay;
  99. Window        theWindow;
  100. GC            theGC;
  101. Colormap      theColormap;
  102. XColor        color;
  103. Drawable      drawable;
  104. Pixmap        pixmap;
  105. XSegment      gridZero[2], gridLinesX[NGRIDX*2], gridLinesY[NGRIDY*2];
  106. XSegment      visibCircleSatPix[NSEGSVC], visibCircleGndPix[NSEGSVC];
  107. XSegment      visibCircleSunPix[NSEGSVC], groundTrackPix[NSEGSGT];
  108. XPoint        stsPoints[NSTSPOINTS], mirPoints[NMIRPOINTS];
  109. Widget        toplevel, frame;
  110. XtAppContext  appContext;
  111. Arg           warg[3];
  112.  
  113. double        gndLtd, gndLng, satLtd, satLng, satHgt, sunLtd, sunLng, sunHgt, 
  114.               ctyLtd, ctyLng, satLtdNew, satLngNew, satAzi, satEle, 
  115.               satLngAdd, satLngFact, dLng, satLng0, phi, phiFact, inc, 
  116.               separation, sepStep, sep, dh;
  117.  
  118. long          timeInterval;
  119.  
  120. unsigned long numColors, foregroundPixel, backgroundPixel, 
  121.               redPixel, greenPixel, lightGreenPixel,
  122.               nightBluePixel, darkBluePixel, oceanBluePixel,
  123.               lightBluePixel, veryLightBluePixel,
  124.               darkYellowPixel, lightYellowPixel,
  125.               blackPixel, darkGreyPixel, mediumGreyPixel, whitePixel;
  126.  
  127. unsigned int  w, h;
  128.  
  129. int           x, y, theScreen, secCount, secs, maxSecs, stsFlag, nPoints, 
  130.               nFramePoints, nFramePointsTop, initFlag, 
  131.               gndLocX, gndLocY, satLocX, satLocY, sunLocX, sunLocY, 
  132.               ctyLocX, ctyLocY, satLocBakX, satLocBakY, 
  133.               redrawFlag, daylightFlag, satTypeFlag, satSpot, verboseFlag;
  134.  
  135. char          str[80], appName[80], gndName[80];
  136.  
  137. /******************************************************************************/
  138. /*                                                                            */
  139. /* external functions                                                         */
  140. /*                                                                            */
  141. /******************************************************************************/
  142.  
  143. extern double absol(), reduce();
  144. extern void   multMatVec();
  145.  
  146. extern void   CalcGrid();
  147. extern void   CalcGroundTrack();
  148. extern void   CalcMapLocation();
  149. extern void   CalcVisibCircle();
  150. extern void   CleanSegments();
  151. extern void   CreateColors();
  152. extern void   DrawFrame();
  153. extern void   DrawMap();
  154. extern void   DrawMir();
  155. extern void   DrawSat();
  156. extern void   DrawShuttle();
  157. extern void   Quit();
  158. extern void   RedrawMap();
  159. extern void   ResizeMap();
  160. extern void   TimeLoop();
  161.  
  162. /******************************************************************************/
  163. /*                                                                            */
  164. /* reduce: reduces number into specified interval (e.g. -PI, +PI)             */
  165. /*                                                                            */
  166. /******************************************************************************/
  167.  
  168. double reduce(value,rangeMin,rangeMax)
  169.  
  170. double value, rangeMin, rangeMax;
  171.  
  172. {
  173.     double range, rangeFrac, fullRanges, retval;
  174.  
  175.     range     = rangeMax - rangeMin;
  176.     rangeFrac = (rangeMax - value) / range;
  177.  
  178.     modf(rangeFrac,&fullRanges);
  179.  
  180.     retval = value + fullRanges * range;
  181.  
  182.     if (retval > rangeMax)
  183.         retval -= range;
  184.  
  185.     return(retval);
  186. }
  187.  
  188. /******************************************************************************/
  189. /*                                                                            */
  190. /* DrawShuttle: draws space shuttle                                           */
  191. /*                                                                            */
  192. /******************************************************************************/
  193.  
  194. void DrawShuttle()
  195.  
  196. {
  197.     int i;
  198.  
  199.     nPoints = sizeof (stsPointsWhite) / sizeof (XPoint);
  200.  
  201.     for (i = 0; i < nPoints; i++)
  202.     {
  203.         stsPoints[i].x = stsPointsWhite[i].x + (short int) satLocX;
  204.         stsPoints[i].y = stsPointsWhite[i].y + (short int) satLocY;
  205.     }
  206.  
  207.     if (daylightFlag)
  208.         XSetForeground(theDisplay,theGC,whitePixel);
  209.     else
  210.         XSetForeground(theDisplay,theGC,mediumGreyPixel);
  211.  
  212.     XDrawPoints(theDisplay,drawable,theGC,stsPoints,nPoints,CoordModeOrigin);
  213.  
  214.     nPoints = sizeof (stsPointsBlack) / sizeof (XPoint);
  215.  
  216.     for (i = 0; i < nPoints; i++)
  217.     {
  218.         stsPoints[i].x = stsPointsBlack[i].x + (short int) satLocX;
  219.         stsPoints[i].y = stsPointsBlack[i].y + (short int) satLocY;
  220.     }
  221.  
  222.     XSetForeground(theDisplay,theGC,blackPixel);
  223.     XDrawPoints(theDisplay,drawable,theGC,stsPoints,nPoints,CoordModeOrigin);
  224.  
  225.     return;
  226. }
  227.  
  228. /******************************************************************************/
  229. /*                                                                            */
  230. /* DrawMir: draws Mir space station                                           */
  231. /*                                                                            */
  232. /******************************************************************************/
  233.  
  234. void DrawMir()
  235.  
  236. {
  237.     int i;
  238.  
  239.     nPoints = sizeof (mirPointsWhite) / sizeof (XPoint);
  240.  
  241.     for (i = 0; i < nPoints; i++)
  242.     {
  243.         mirPoints[i].x = mirPointsWhite[i].x + (short int) satLocX;
  244.         mirPoints[i].y = mirPointsWhite[i].y + (short int) satLocY;
  245.     }
  246.  
  247.     if (daylightFlag)
  248.         XSetForeground(theDisplay,theGC,whitePixel);
  249.     else
  250.         XSetForeground(theDisplay,theGC,mediumGreyPixel);
  251.  
  252.     XDrawPoints(theDisplay,drawable,theGC,mirPoints,nPoints,CoordModeOrigin);
  253.  
  254.     nPoints = sizeof (mirPointsBlack) / sizeof (XPoint);
  255.  
  256.     for (i = 0; i < nPoints; i++)
  257.     {
  258.         mirPoints[i].x = mirPointsBlack[i].x + (short int) satLocX;
  259.         mirPoints[i].y = mirPointsBlack[i].y + (short int) satLocY;
  260.     }
  261.  
  262.     XSetForeground(theDisplay,theGC,blackPixel);
  263.     XDrawPoints(theDisplay,drawable,theGC,mirPoints,nPoints,CoordModeOrigin);
  264.  
  265.     return;
  266. }
  267.  
  268. /******************************************************************************/
  269. /*                                                                            */
  270. /* DrawSat: draws satellite                                                   */
  271. /*                                                                            */
  272. /*          selectFlag = TRUE    color is blue   (status = SELECT or MARK)    */
  273. /*                     = FALSE   color is yellow                              */
  274. /*                                                                            */
  275. /*          dayFlag    = TRUE    color is light  (blue or yellow)             */
  276. /*                     = FALSE   color is dark   (blue or yellow)             */
  277. /*                                                                            */
  278. /******************************************************************************/
  279.  
  280. void DrawSat(nStr,selectFlag,dayFlag)
  281.  
  282. int  selectFlag, dayFlag;
  283. char *nStr;
  284.  
  285. {
  286.     satSpot = (selectFlag) ? TRKSPOT : SATSPOT;
  287.  
  288.     if (selectFlag && dayFlag)
  289.         XSetForeground(theDisplay,theGC,lightBluePixel);
  290.     if (selectFlag && !dayFlag)
  291.         XSetForeground(theDisplay,theGC,darkBluePixel);
  292.  
  293.     if (!selectFlag && dayFlag)
  294.         XSetForeground(theDisplay,theGC,lightYellowPixel);
  295.     if (!selectFlag && !dayFlag)
  296.         XSetForeground(theDisplay,theGC,darkYellowPixel);
  297.  
  298.     XFillRectangle(theDisplay,drawable,theGC,
  299.                    satLocX - (int) satSpot ,satLocY - (int) satSpot,
  300.                    (unsigned int) (satSpot*2+1),(unsigned int) (satSpot*2+1));
  301.  
  302.     x = ((int) (MARGINLFT + MAPWIDTH) - satLocX > 100) 
  303.                  ? 10 : -10 - ((int) (strlen(str)) * 6);
  304.  
  305.     y = (satLocY - (int) MARGINTOP < 25) ? 20 : -8;
  306.  
  307.     if (!dayFlag)
  308.     {
  309.         if (selectFlag)
  310.             XSetForeground(theDisplay,theGC,lightBluePixel);
  311.         else
  312.             XSetForeground(theDisplay,theGC,lightYellowPixel);
  313.     }
  314.  
  315.     XDrawString(theDisplay,drawable,theGC,satLocX+x,satLocY+y,
  316.                 nStr,(int) strlen(nStr));
  317.  
  318.     return;
  319. }
  320.  
  321. /******************************************************************************/
  322. /*                                                                            */
  323. /* DrawFrame: draws the frame around world map and the text in the header and */
  324. /*            footer line                                                     */
  325. /*                                                                            */
  326. /******************************************************************************/
  327.  
  328. void DrawFrame()
  329.  
  330. {
  331.     x = 0;
  332.     y = 0;
  333.     w = (unsigned int) (MARGINLFT + MAPWIDTH + MARGINRGT);
  334.     h = (unsigned int) MARGINTOP;
  335.  
  336.     XSetForeground(theDisplay,theGC,blackPixel);
  337.     XFillRectangle(theDisplay,drawable,theGC,x,y,w,h);
  338.  
  339.     XSetForeground(theDisplay,theGC,whitePixel);
  340.  
  341.     sprintf(str,"STS-71");
  342.     XDrawString(theDisplay,drawable,theGC,(int) (MARGINLFT+2),
  343.                 (int) HEADERROW,str,(int) strlen(str));
  344.  
  345.     sprintf(str,"Orbit: 85");
  346.     XDrawString(theDisplay,drawable,theGC,(int) (MARGINLFT+0.17*MAPWIDTH),
  347.                 (int) HEADERROW,str,(int) strlen(str));
  348.  
  349. /*
  350.     sprintf(str,"Azi: %3.0f",satAzi);
  351.     XDrawString(theDisplay,drawable,theGC,(int) (MARGINLFT+0.32*MAPWIDTH),
  352.                 (int) HEADERROW,str,(int) strlen(str));
  353.  
  354.     sprintf(str,"Ele: %3.0f",satEle);
  355.     XDrawString(theDisplay,drawable,theGC,(int) (MARGINLFT+0.42*MAPWIDTH),
  356.                 (int) HEADERROW,str,(int) strlen(str));
  357. */
  358.  
  359.     sprintf(str,"Lat: %2.0f %s",fabs(satLtd),(satLtd >= 0.0) ? "N" : "S");
  360.     XDrawString(theDisplay,drawable,theGC,(int) (MARGINLFT+0.38*MAPWIDTH),
  361.                 (int) HEADERROW,str,(int) strlen(str));
  362.  
  363.     sprintf(str,"Lng: %3.0f %s",fabs(satLng),(satLng >= 0.0) ? "W" : "E");
  364.     XDrawString(theDisplay,drawable,theGC,(int) (MARGINLFT+0.50*MAPWIDTH),
  365.                 (int) HEADERROW,str,(int) strlen(str));
  366.  
  367.     sprintf(str,"03Jun95  17:00:%02d UTC",secs);
  368.     XDrawString(theDisplay,drawable,theGC,(int) (MARGINLFT+0.70*MAPWIDTH),
  369.                 (int) HEADERROW,str,(int) strlen(str));
  370.  
  371.     x = 0;
  372.     y = (int) (MARGINTOP + MAPHEIGHT);
  373.     w = (unsigned int) (MARGINLFT + MAPWIDTH + MARGINRGT);
  374.     h = (unsigned int) MARGINBOT;
  375.  
  376.     XSetForeground(theDisplay,theGC,blackPixel);
  377.     XFillRectangle(theDisplay,drawable,theGC,x,y,w,h);
  378.  
  379.     XSetForeground(theDisplay,theGC,whitePixel);
  380.  
  381.     sprintf(str,"Ground Track: ");
  382.     sprintf(str,"%s  96.0 km ESE of Hanga Roa, Easter Island (Chile)",str);
  383.     XDrawString(theDisplay,drawable,theGC,
  384.                 (int) (MARGINLFT+2),(int) FOOTERROW,str,(int) strlen(str));
  385.  
  386.     x = 0;
  387.     y = (int) MARGINTOP;
  388.     w = (unsigned int) MARGINLFT;
  389.     h = (unsigned int) MAPHEIGHT;
  390.  
  391.     XSetForeground(theDisplay,theGC,blackPixel);
  392.     XFillRectangle(theDisplay,drawable,theGC,x,y,w,h);
  393.  
  394.     x = (int) (MARGINLFT + MAPWIDTH);
  395.     y = (int) MARGINTOP;
  396.     w = (unsigned int) MARGINRGT;
  397.     h = (unsigned int) MAPHEIGHT;
  398.  
  399.     XFillRectangle(theDisplay,drawable,theGC,x,y,w,h);
  400.  
  401.     return;
  402. }
  403.  
  404. /******************************************************************************/
  405. /*                                                                            */
  406. /* DrawMap: draws window with world map and other features                    */
  407. /*                                                                            */
  408. /******************************************************************************/
  409.  
  410. void DrawMap()
  411.  
  412. {
  413.     int i;
  414.  
  415.     if (initFlag)
  416.         XClearWindow(theDisplay,drawable);
  417.  
  418.     /* draw frame and header line */
  419.  
  420.     DrawFrame();
  421.  
  422.     /* draw world map */
  423.  
  424.     if (initFlag)
  425.         pixmap = XCreateBitmapFromData(theDisplay,(Drawable) drawable,
  426.                      (char *) world_bits,MAPWIDTH,MAPHEIGHT);
  427.  
  428.     XSetForeground(theDisplay,theGC,foregroundPixel);
  429.     XSetBackground(theDisplay,theGC,backgroundPixel);
  430.     XCopyPlane(theDisplay,(Drawable) pixmap,(Drawable) drawable,theGC,0,0,
  431.                MAPWIDTH,MAPHEIGHT,(int) MARGINLFT,(int) MARGINTOP,1);
  432.  
  433.     /* draw grid */
  434.  
  435.     XSetForeground(theDisplay,theGC,mediumGreyPixel);
  436.     XDrawSegments(theDisplay,drawable,theGC,gridZero,2);
  437.  
  438.     XSetForeground(theDisplay,theGC,darkGreyPixel);
  439.     XDrawSegments(theDisplay,drawable,theGC,gridLinesX,NGRIDX*2);
  440.     XDrawSegments(theDisplay,drawable,theGC,gridLinesY,NGRIDY*2);
  441.  
  442.     /* draw Sun and terminator */
  443.  
  444.     XSetForeground(theDisplay,theGC,lightYellowPixel);
  445.     XDrawSegments(theDisplay,drawable,theGC,visibCircleSunPix,NSEGSVC);
  446.     sprintf(str,"*");
  447.     XDrawString(theDisplay,drawable,theGC,sunLocX-2,sunLocY+5,
  448.                 str,(int) strlen(str));
  449.  
  450.     /* draw ground station */
  451.  
  452.     XSetForeground(theDisplay,theGC,redPixel);
  453.     XDrawSegments(theDisplay,drawable,theGC,visibCircleGndPix,NSEGSVC);
  454.  
  455.     XFillRectangle(theDisplay,drawable,theGC,
  456.                    gndLocX - (int) GNDSPOT,gndLocY - (int) GNDSPOT,
  457.                    (unsigned int) (GNDSPOT*2+1),(unsigned int) (GNDSPOT*2+1));
  458.  
  459.     x = ((int) (MARGINLFT + MAPWIDTH) - gndLocX > 100) 
  460.                  ? 10 : -10 - ((int) (strlen(str)) * 6);
  461.  
  462.     y = (gndLocY - (int) MARGINTOP < 25) ? 20 : -8;
  463.  
  464.     XSetForeground(theDisplay,theGC,veryLightBluePixel);
  465.     XDrawString(theDisplay,drawable,theGC,gndLocX+x,gndLocY+y,
  466.                 gndName,(int) strlen(gndName));
  467.  
  468.     /* draw nearest city */
  469.  
  470.     CalcMapLocation(ctyLtd,ctyLng,&ctyLocX,&ctyLocY);
  471.  
  472.     XSetForeground(theDisplay,theGC,redPixel);
  473.     XFillRectangle(theDisplay,drawable,theGC,
  474.                    ctyLocX - (int) CTYSPOT,ctyLocY - (int) CTYSPOT,
  475.                    (unsigned int) (CTYSPOT*2+1),(unsigned int) (CTYSPOT*2+1));
  476.  
  477.     /* draw ground track */
  478.  
  479.     XSetForeground(theDisplay,theGC,lightBluePixel);
  480.     XDrawSegments(theDisplay,drawable,theGC,groundTrackPix,NSEGSGT);
  481.  
  482.     /* draw visibility circle */
  483.  
  484.     XSetForeground(theDisplay,theGC,veryLightBluePixel);
  485.     XDrawSegments(theDisplay,drawable,theGC,visibCircleSatPix,NSEGSVC);
  486.  
  487.     /* draw all satellites */
  488.  
  489.     satTypeFlag = STS;
  490.  
  491.     for (i = 0; i < 2; i++)
  492.     {
  493. /*
  494.         CalcMapLocation(satLat*CRD,satLong*CRD,&satLocX,&satLocY);
  495. */
  496.         satTypeFlag = (satTypeFlag == MIR) ? STS : MIR;
  497.  
  498.         switch(satTypeFlag)
  499.         {
  500.             case BASIC:
  501. /*
  502.                 strcpy(str,"%s",satName);
  503.                 DrawSat(str,FALSE,TRUE);
  504. */
  505.                 break;
  506.  
  507.             case MIR:
  508.                 CalcMapLocation(satLtd,satLng,&satLocX,&satLocY);
  509.                 DrawMir();
  510.                 break;
  511.  
  512.             case STS:
  513.                 satLngNew  = satLng - separation;
  514.                 satLngNew  = reduce(satLngNew,-180.0,180.0);
  515.                 satLtdNew  = satLtd + separation;
  516.                 satLocBakX = satLocX;
  517.                 satLocBakY = satLocY;
  518.  
  519.                 CalcMapLocation(satLtdNew,satLngNew,&satLocX,&satLocY);
  520.  
  521.                 sep = reduce((satLng-satLngNew),0.0,360.0);
  522.                 dh  = satHgt - satHgt;
  523.  
  524.                 if ((sep < 5.0 || sep > 355.0) && fabs(dh) < 5.0)
  525.                 {
  526.                     satLocX = satLocBakX -  8;             /* Mir-STS docking */
  527.                     satLocY = satLocBakY + 16;
  528.                 }
  529.  
  530.                 DrawShuttle();
  531.                 break;
  532.  
  533.             default:
  534.                 break;
  535.         }
  536.     }
  537.  
  538.     daylightFlag = (daylightFlag) ? FALSE : TRUE;
  539.  
  540.     if (daylightFlag)
  541.     {
  542.         gndLtd =  -7.3;
  543.         gndLng = -72.4;
  544.         sprintf(gndName,"%s","DGS");
  545.     }
  546.  
  547.     else
  548.     {
  549.         gndLtd =  35.4;
  550.         gndLng = 116.9;
  551.         sprintf(gndName,"GDS");
  552.  
  553.         gndLtd =  20.7;
  554.         gndLng = 156.3;
  555.         sprintf(gndName,"AMOS");
  556.     }
  557.  
  558.     /* draw other satellites in multisat list */
  559.  
  560.     strcpy(str,"HST");
  561.     CalcMapLocation(15.0,45.0,&satLocX,&satLocY);
  562.     DrawSat(str,FALSE,daylightFlag);
  563.  
  564.     strcpy(str,"KO-23");
  565.     CalcMapLocation(-45.0,95.0,&satLocX,&satLocY);
  566.     DrawSat(str,TRUE,daylightFlag);
  567.  
  568.     sprintf(str,"GRO");
  569.     CalcMapLocation(-10.0,75.0,&satLocX,&satLocY);
  570.     DrawSat(str,TRUE,daylightFlag);
  571.  
  572.     sprintf(str,"UARS");
  573.     satLngNew = satLng + 90.0;
  574.     satLngNew = reduce(satLngNew,-180.0,180.0);
  575.     CalcMapLocation(satLtd,satLngNew,&satLocX,&satLocY);
  576.     DrawSat(str,FALSE,daylightFlag);
  577.  
  578.     /* raise map */
  579.  
  580.     if (initFlag)
  581.         XMapRaised(theDisplay,(Drawable) drawable);
  582.  
  583.     initFlag = FALSE;
  584.     return;
  585. }
  586.  
  587. /******************************************************************************/
  588. /*                                                                            */
  589. /* RedrawMap: redraws map                                                     */
  590. /*                                                                            */
  591. /******************************************************************************/
  592.  
  593. void RedrawMap()
  594.  
  595. {
  596.     if (redrawFlag)
  597.     {
  598.         if (verboseFlag)
  599.             printf("redrawing map ...\n");
  600.  
  601.         CalcGroundTrack();
  602.  
  603.         CalcMapLocation(gndLtd,gndLng,&gndLocX,&gndLocY);
  604.         CalcMapLocation(satLtd,satLng,&satLocX,&satLocY);
  605.         CalcMapLocation(sunLtd,sunLng,&sunLocX,&sunLocY);
  606.  
  607.         CalcVisibCircle(&visibCircleGndPix[0],gndLtd,gndLng,satHgt);
  608.         CalcVisibCircle(&visibCircleSatPix[0],satLtd,satLng,satHgt);
  609.         CalcVisibCircle(&visibCircleSunPix[0],sunLtd,sunLng,sunHgt);
  610.  
  611.         DrawMap();
  612.         redrawFlag = FALSE;
  613.     }
  614.  
  615.     return;
  616. }
  617.  
  618. /******************************************************************************/
  619. /*                                                                            */
  620. /* ResizeMap: resizes map                                                     */
  621. /*                                                                            */
  622. /******************************************************************************/
  623.  
  624. void ResizeMap()
  625.  
  626. {
  627.     if (verboseFlag)
  628.         printf("--> this doesn't work yet!\n");
  629.  
  630.     return;
  631. }
  632.  
  633. /******************************************************************************/
  634. /*                                                                            */
  635. /* TimeLoop: performs cyclic update of satellite position                     */
  636. /*                                                                            */
  637. /******************************************************************************/
  638.  
  639. void TimeLoop(i,id)
  640.  
  641. int i;
  642. XtIntervalId *id;
  643.  
  644. {
  645.     secCount += (int) (timeInterval / 1000);
  646.  
  647.     sunLng   += (double) timeInterval / 1000.0 / 86400.0 * 360;
  648.     sunLng    = reduce(sunLng,-180.0,180.0);
  649.  
  650.     if (secCount > maxSecs)
  651.         secCount = 0;
  652.  
  653.     secs   = secCount % 60;
  654.     dLng   = satLngFact * fabs(satLngAdd);
  655.     satLtd = -inc * sin((dLng * (double) secCount) * CDR) + ONEPPM;
  656.  
  657.     phi    = -phiFact * (double) secCount * satLngAdd / 3.0 / 360.0;
  658.     satLng = reduce(satLng0 + ((double) secCount) * dLng + phi,-180.0,180.0);
  659.  
  660.     if (separation < -22.5)
  661.     {
  662.         separation = -22.5;
  663.         sepStep    =   0.5;
  664.     }
  665.  
  666.     if (separation > 0.0)
  667.     {
  668.         separation =  0.0;
  669.         sepStep    = -0.5;
  670.     }
  671.  
  672.     separation += sepStep;
  673.  
  674.     CalcGroundTrack();
  675.  
  676.     CalcMapLocation(gndLtd,gndLng,&gndLocX,&gndLocY);
  677.     CalcMapLocation(satLtd,satLng,&satLocX,&satLocY);
  678.     CalcMapLocation(sunLtd,sunLng,&sunLocX,&sunLocY);
  679.  
  680.     CalcVisibCircle(&visibCircleGndPix[0],gndLtd,gndLng,satHgt);
  681.     CalcVisibCircle(&visibCircleSatPix[0],satLtd,satLng,satHgt);
  682.     CalcVisibCircle(&visibCircleSunPix[0],sunLtd,sunLng,sunHgt);
  683.  
  684.     redrawFlag = TRUE;
  685.     DrawMap();
  686.     timeInterval = 2000L;
  687.     XtAppAddTimeOut(appContext,timeInterval,TimeLoop,0);
  688.  
  689.     return;
  690. }
  691.  
  692. /******************************************************************************/
  693. /*                                                                            */
  694. /* QuitMain: quits main program                                               */
  695. /*                                                                            */
  696. /******************************************************************************/
  697.  
  698. void Quit()
  699.  
  700. {
  701.     if (verboseFlag)
  702.         printf("closing window ...\n");
  703.  
  704.     XFreePixmap(theDisplay,pixmap);
  705.     XFreeGC(theDisplay,theGC);
  706.     XDestroyWindow(theDisplay,XtWindow(toplevel));
  707.     XCloseDisplay(theDisplay);
  708.  
  709.     if (verboseFlag)
  710.         printf("\ndid you have a good time watching this?\n\n");
  711.  
  712.     exit(-1);
  713. }
  714.  
  715. /******************************************************************************/
  716. /*                                                                            */
  717. /* CreateColors: creates all colors needed                                    */
  718. /*                                                                            */
  719. /******************************************************************************/
  720.  
  721. void CreateColors()
  722.  
  723. {
  724.     theColormap = DefaultColormap(theDisplay,theScreen);
  725.     color.flags = DoRed | DoGreen | DoBlue;
  726.  
  727.     color.red   = (unsigned short) 65535;                              /* red */
  728.     color.green = (unsigned short) 20000;
  729.     color.blue  = (unsigned short) 25000;
  730.  
  731.     XAllocColor(theDisplay,theColormap,&color);
  732.     redPixel = color.pixel;
  733.  
  734.     color.red   = (unsigned short) 18000;                            /* green */
  735.     color.green = (unsigned short) 48000;
  736.     color.blue  = (unsigned short)  2000;
  737.  
  738.     XAllocColor(theDisplay,theColormap,&color);
  739.     greenPixel = color.pixel;
  740.  
  741.     color.red   = (unsigned short) 18000;                      /* light green */
  742.     color.green = (unsigned short) 52000;
  743.     color.blue  = (unsigned short)  2000;
  744.  
  745.     XAllocColor(theDisplay,theColormap,&color);
  746.     lightGreenPixel = color.pixel;
  747.  
  748.     color.red   = (unsigned short)  5000;                       /* night blue */
  749.     color.green = (unsigned short)  5000;
  750.     color.blue  = (unsigned short) 35000;
  751.  
  752.     XAllocColor(theDisplay,theColormap,&color);
  753.     nightBluePixel = color.pixel;
  754.  
  755.     color.red   = (unsigned short) 34000;                        /* dark blue */
  756.     color.green = (unsigned short) 34000;
  757.     color.blue  = (unsigned short) 52000;
  758.  
  759.     XAllocColor(theDisplay,theColormap,&color);
  760.     darkBluePixel = color.pixel;
  761.  
  762.     color.red   = (unsigned short) 12500;                       /* ocean blue */
  763.     color.green = (unsigned short)  7500;
  764.     color.blue  = (unsigned short) 50000;
  765.  
  766.     XAllocColor(theDisplay,theColormap,&color);
  767.     oceanBluePixel = color.pixel;
  768.  
  769.     color.red   = (unsigned short) 40000;                       /* light blue */
  770.     color.green = (unsigned short) 60000;
  771.     color.blue  = (unsigned short) 65535;
  772.  
  773.     XAllocColor(theDisplay,theColormap,&color);
  774.     lightBluePixel = color.pixel;
  775.  
  776.     color.red   = (unsigned short) 62000;                  /* very light blue */
  777.     color.green = (unsigned short) 65535;
  778.     color.blue  = (unsigned short) 65535;
  779.  
  780.     XAllocColor(theDisplay,theColormap,&color);
  781.     veryLightBluePixel = color.pixel;
  782.  
  783.     color.red   = (unsigned short) 52000;                      /* dark yellow */
  784.     color.green = (unsigned short) 52000;
  785.     color.blue  = (unsigned short) 34000;
  786.  
  787.     XAllocColor(theDisplay,theColormap,&color);
  788.     darkYellowPixel = color.pixel;
  789.  
  790.     color.red   = (unsigned short) 65535;                     /* light yellow */
  791.     color.green = (unsigned short) 65535;
  792.     color.blue  = (unsigned short) 35000;
  793.  
  794.     XAllocColor(theDisplay,theColormap,&color);
  795.     lightYellowPixel = color.pixel;
  796.  
  797.     color.red   = (unsigned short)     0;                            /* black */
  798.     color.green = (unsigned short)     0;
  799.     color.blue  = (unsigned short)     0;
  800.  
  801.     XAllocColor(theDisplay,theColormap,&color);
  802.     blackPixel = color.pixel;
  803.  
  804.     color.red   = (unsigned short) 40000;                        /* dark grey */
  805.     color.green = (unsigned short) 40000;
  806.     color.blue  = (unsigned short) 45000;
  807.  
  808.     XAllocColor(theDisplay,theColormap,&color);
  809.     darkGreyPixel = color.pixel;
  810.  
  811.     color.red   = (unsigned short) 48000;                      /* medium grey */
  812.     color.green = (unsigned short) 48000;
  813.     color.blue  = (unsigned short) 52000;
  814.  
  815.     XAllocColor(theDisplay,theColormap,&color);
  816.     mediumGreyPixel = color.pixel;
  817.  
  818.     color.red   = (unsigned short) 65535;                            /* white */
  819.     color.green = (unsigned short) 65535;
  820.     color.blue  = (unsigned short) 65535;
  821.  
  822.     XAllocColor(theDisplay,theColormap,&color);
  823.     whitePixel = color.pixel;
  824.  
  825.     return;
  826. }
  827.  
  828. /******************************************************************************/
  829. /*                                                                            */
  830. /* CalcGrid: calculates grid                                                  */
  831. /*                                                                            */
  832. /******************************************************************************/
  833.  
  834. void CalcGrid()
  835.  
  836. {
  837.     double gridStepX, gridStepY;
  838.     int    i, j, mapCenterX, mapCenterY;
  839.  
  840.     mapCenterX     = (int) (MARGINLFT + MAPWIDTH  / 2 - 1);
  841.     mapCenterY     = (int) (MARGINTOP + MAPHEIGHT / 2 - 1);
  842.  
  843.     gridZero[0].x1 = mapCenterX;                             /* zero meridian */
  844.     gridZero[0].x2 = mapCenterX;                 
  845.     gridZero[0].y1 = (int) MARGINTOP;
  846.     gridZero[0].y2 = (int) (MARGINTOP + MAPHEIGHT - 1);
  847.     
  848.     gridZero[1].x1 = (int) MARGINLFT;                              /* equator */
  849.     gridZero[1].x2 = (int) (MARGINLFT + MAPWIDTH - 1);
  850.     gridZero[1].y1 = mapCenterY;
  851.     gridZero[1].y2 = mapCenterY;
  852.     
  853.     gridStepX      = GRIDSTEPX * GRIDSCALEX;
  854.     gridStepY      = GRIDSTEPY * GRIDSCALEY;
  855.  
  856.     for (i = 0; i < NGRIDX; i++)                                  /* vertical */
  857.     {
  858.         j = 2 * i;
  859.  
  860.         gridLinesX[j].x1   = mapCenterX + (int) ((double) (i+1) * gridStepX);
  861.         gridLinesX[j].x2   = mapCenterX + (int) ((double) (i+1) * gridStepX);
  862.  
  863.         gridLinesX[j+1].x1 = mapCenterX - (int) ((double) (i+1) * gridStepX);
  864.         gridLinesX[j+1].x2 = mapCenterX - (int) ((double) (i+1) * gridStepX);
  865.  
  866.         gridLinesX[j].y1   = (int) MARGINTOP;
  867.         gridLinesX[j].y2   = (int) (MARGINTOP + MAPHEIGHT - 1);
  868.  
  869.         gridLinesX[j+1].y1 = (int) MARGINTOP;
  870.         gridLinesX[j+1].y2 = (int) (MARGINTOP + MAPHEIGHT - 1);
  871.     }
  872.  
  873.     for (i = 0; i < NGRIDY; i++)                                /* horizontal */
  874.     {
  875.         j = 2 * i;
  876.  
  877.         gridLinesY[j].x1   = (int) MARGINLFT;
  878.         gridLinesY[j].x2   = (int) (MARGINLFT + MAPWIDTH - 1);
  879.  
  880.         gridLinesY[j+1].x1 = (int) MARGINLFT;
  881.         gridLinesY[j+1].x2 = (int) (MARGINLFT + MAPWIDTH - 1);
  882.  
  883.         gridLinesY[j].y1   = mapCenterY + (int) ((double) (i+1) * gridStepY);
  884.         gridLinesY[j].y2   = mapCenterY + (int) ((double) (i+1) * gridStepY);
  885.  
  886.         gridLinesY[j+1].y1 = mapCenterY - (int) ((double) (i+1) * gridStepY);
  887.         gridLinesY[j+1].y2 = mapCenterY - (int) ((double) (i+1) * gridStepY);
  888.     }
  889.  
  890.     return;
  891. }
  892.  
  893. /******************************************************************************/
  894. /*                                                                            */
  895. /* CalcMapLocation: calculates location of ground station, satellite and Sun  */
  896. /*                                                                            */
  897. /******************************************************************************/
  898.  
  899. void CalcMapLocation(mapLtd,mapLng,mapX,mapY)
  900.  
  901. double mapLtd, mapLng;
  902. int    *mapX, *mapY;
  903.  
  904. {
  905.     *mapX  = (int) ((MAPWIDTHD  / 2.0 - mapLng) * GRIDSCALEX);
  906.     *mapY  = (int) ((MAPHEIGHTD / 2.0 - mapLtd) * GRIDSCALEY);
  907.  
  908.     *mapX += (int) MARGINLFT - 1;
  909.     *mapY += (int) MARGINTOP - 1;
  910.  
  911.     return;
  912. }
  913.  
  914. /******************************************************************************/
  915. /*                                                                            */
  916. /* CalcVisibCircle: calculates circle of visibility around sub-satellite      */
  917. /*                  point, using an Euler matrix for the vector rotation      */
  918. /*                                                                            */
  919. /******************************************************************************/
  920.  
  921. void CalcVisibCircle(visibCirclePix,circLtd,circLng,circHgt)
  922.  
  923. XSegment *visibCirclePix;
  924. double   circLtd, circLng, circHgt;
  925.  
  926. {
  927.     double descMat[3][3], u[3], q[3];
  928.     double arg, circStep, qabs;
  929.     double theta, psi, gamma, beta, lambda, lat, lng;
  930.     double cosTheta, sinTheta, cosPsi, sinPsi;
  931.     double cosBeta, sinBeta, cosLambda, sinLambda;
  932.  
  933.     int    i, k, posX, posY;
  934.  
  935.     theta    = HALFPI - circLtd*CDR;
  936.     psi      = HALFPI - circLng*CDR;
  937.  
  938.     cosTheta = cos(theta);
  939.     sinTheta = sin(theta);
  940.     cosPsi   = cos(psi);
  941.     sinPsi   = sin(psi);
  942.  
  943.     descMat[0][0] =  sinPsi*cosTheta;
  944.     descMat[0][1] = -cosPsi;
  945.     descMat[0][2] =  sinPsi*sinTheta;
  946.     descMat[1][0] =  cosPsi*cosTheta;
  947.     descMat[1][1] =  sinPsi;
  948.     descMat[1][2] =  cosPsi*sinTheta;
  949.     descMat[2][0] = -sinTheta;
  950.     descMat[2][1] =  0.0;
  951.     descMat[2][2] =  cosTheta;
  952.  
  953.     arg      = EARTHRADIUS / (EARTHRADIUS + circHgt);
  954.  
  955.     if (arg >  1.0) arg =  1.0;
  956.     if (arg < -1.0) arg = -1.0;
  957.  
  958.     gamma    = acos(arg);
  959.  
  960.     beta     = HALFPI - gamma;
  961.     cosBeta  = cos(beta);
  962.     sinBeta  = sin(beta);
  963.  
  964.     circStep = 360.0 / ((double) NSEGSVC);
  965.  
  966.     for (k = 0; k < NSEGSVC;  k++)
  967.     {
  968.         lambda    = (double) (circStep * k) * CDR;
  969.         cosLambda = cos(lambda);
  970.         sinLambda = sin(lambda);
  971.  
  972.         u[0] = cosLambda*cosBeta;
  973.         u[1] = sinLambda*cosBeta;
  974.         u[2] = sinBeta;
  975.  
  976.         multMatVec(u,q,descMat);
  977.  
  978.         qabs  = absol(q);
  979.  
  980.         for (i = 0; i <= 2; i++)
  981.             q[i] /= qabs;
  982.  
  983.         arg   = q[2];
  984.  
  985.         if (arg >  1.0) arg =  1.0;
  986.         if (arg < -1.0) arg = -1.0;
  987.  
  988.         lat   = asin(arg) * CRD;
  989.  
  990.         q[2]  = 0.0;
  991.         qabs  = absol(q);
  992.  
  993.         q[0] /= qabs;
  994.         q[1] /= qabs;
  995.  
  996.         lng   = atan2(q[1],q[0]) * CRD;
  997.         lng   = reduce(lng,-MAPWIDTHD/2.0,MAPWIDTHD/2.0);
  998.  
  999.         posX  = (int) ((MAPWIDTHD  / 2.0 - lng) * GRIDSCALEX + MARGINLFT - 0.5);
  1000.         posY  = (int) ((MAPHEIGHTD / 2.0 - lat) * GRIDSCALEY + MARGINTOP - 0.5);
  1001.  
  1002.         visibCirclePix[k].x1 = (short int) posX;
  1003.         visibCirclePix[k].y1 = (short int) posY;
  1004.  
  1005.         if (k > 0)
  1006.         {
  1007.             visibCirclePix[k-1].x2 = visibCirclePix[k].x1;
  1008.             visibCirclePix[k-1].y2 = visibCirclePix[k].y1;
  1009.         }
  1010.     }
  1011.  
  1012.     visibCirclePix[NSEGSVC-1].x2 = visibCirclePix[0].x1;      /* close circle */
  1013.     visibCirclePix[NSEGSVC-1].y2 = visibCirclePix[0].y1;
  1014.  
  1015.     CleanSegments(&visibCirclePix[0],NSEGSVC,TRUE);
  1016.  
  1017.     return;
  1018. }
  1019.  
  1020. /******************************************************************************/
  1021. /*                                                                            */
  1022. /* CalcGroundTrack: calculates ground track                                   */
  1023. /*                                                                            */
  1024. /******************************************************************************/
  1025.  
  1026. void CalcGroundTrack()
  1027.  
  1028. {
  1029.     int    k, gndX, gndY;
  1030.  
  1031.     dLng = satLngFact * (MAPWIDTHD / (double) NSEGS);
  1032.  
  1033.     for (k = 0; k < NSEGSGT; k++)
  1034.     {
  1035.         phi = -phiFact * (double) k / (double) NSEGSGT;
  1036.  
  1037.         groundTrack[k].lng = reduce(satLng0+(double) k * dLng+phi,-180.0,180.0);
  1038.         groundTrack[k].lat = -inc * sin((dLng * (double) k) * CDR) + ONEPPM;
  1039.     }
  1040.  
  1041.     for (k = 0; k < NSEGSGT; k++)
  1042.     {
  1043.         gndX = (int) ((MAPWIDTHD/2.0  - groundTrack[k].lng) * GRIDSCALEX + 
  1044.                        MARGINLFT - 0.5);
  1045.  
  1046.         gndY = (int) ((MAPHEIGHTD/2.0 - groundTrack[k].lat) * GRIDSCALEY + 
  1047.                        MARGINTOP - 0.5);
  1048.  
  1049.         groundTrackPix[k].x1 = (short int) gndX;
  1050.         groundTrackPix[k].y1 = (short int) gndY;
  1051.  
  1052.         if (k > 0)
  1053.         {
  1054.             groundTrackPix[k-1].x2 = groundTrackPix[k].x1;
  1055.             groundTrackPix[k-1].y2 = groundTrackPix[k].y1;
  1056.         }
  1057.     }
  1058.  
  1059.     groundTrackPix[NSEGSGT-1].x2 = groundTrackPix[NSEGSGT-1].x1;
  1060.     groundTrackPix[NSEGSGT-1].y2 = groundTrackPix[NSEGSGT-1].y1;
  1061.  
  1062.     CleanSegments(&groundTrackPix[0],NSEGSGT,FALSE);
  1063.  
  1064.     return;
  1065. }
  1066.  
  1067. /******************************************************************************/
  1068. /*                                                                            */
  1069. /* CleanSegments: cleans up line segments (wrap around at map boundaries)     */
  1070. /*                                                                            */
  1071. /******************************************************************************/
  1072.  
  1073. void CleanSegments(xSegments,numSegments,visibCircleFlag)
  1074.  
  1075. XSegment *xSegments;
  1076. int      numSegments, visibCircleFlag;
  1077.  
  1078. {
  1079.     int k, k0, n, dx, dy, dX, dY;
  1080.  
  1081.     k0 = (visibCircleFlag) ? 0 : -1;
  1082.  
  1083.     for (k = 0; k < numSegments + k0; k++)
  1084.     {
  1085.         n = (visibCircleFlag && k == numSegments - 1) ? 0 : k+1;
  1086.  
  1087.         if (xSegments[k].x1 - xSegments[k].x2 > (short int) (MAPWIDTH / 2))
  1088.         {
  1089.             dx = (int) (MAPWIDTH + MARGINLFT) - (int) xSegments[k].x1;
  1090.             dX = (int) xSegments[k].x2 - (int) MARGINLFT + dx;
  1091.  
  1092.             dY = (int) (xSegments[k].y2 - xSegments[k].y1);
  1093.             dy = (int) ((double) dY / (double) dX * (double) dx);
  1094.  
  1095.             xSegments[n].x1 = xSegments[k].x2 - (short int) (dX - dx);
  1096.             xSegments[k].x2 = xSegments[k].x1 + (short int) (dx - 1);
  1097.  
  1098.             xSegments[n].y1 = xSegments[k].y2 - (short int) (dY - dy);
  1099.             xSegments[k].y2 = xSegments[k].y1 + (short int) dy;
  1100.         }
  1101.  
  1102.         if (xSegments[k].x2 - xSegments[k].x1 > (short int) (MAPWIDTH / 2))
  1103.         {
  1104.             dx = (int) xSegments[k].x1 - (int) MARGINLFT;
  1105.             dX = (int) (MAPWIDTH + MARGINLFT) - (int) xSegments[k].x2 + dx;
  1106.  
  1107.             dY = (int) (xSegments[k].y2 - xSegments[k].y1);
  1108.             dy = (int) ((double) dY / (double) dX * (double) dx);
  1109.  
  1110.             xSegments[n].x1 = xSegments[k].x2 + (short int) (dX - dx);
  1111.             xSegments[k].x2 = xSegments[k].x1 - (short int) (dx - 1);
  1112.  
  1113.             xSegments[n].y1 = xSegments[k].y2 - (short int) (dY - dy);
  1114.             xSegments[k].y2 = xSegments[k].y1 + (short int) dy;
  1115.         }
  1116.     }
  1117.  
  1118.     for (k = 0; k < numSegments; k++)
  1119.     {
  1120.         if (xSegments[k].y1 < (short int) MARGINTOP)
  1121.             xSegments[k].y1 = (short int) MARGINTOP;
  1122.  
  1123.         if (xSegments[k].y2 < (short int) MARGINTOP)
  1124.             xSegments[k].y2 = (short int) MARGINTOP;
  1125.  
  1126.         if (xSegments[k].y1 > (short int) (MAPHEIGHT + MARGINTOP - 1))
  1127.             xSegments[k].y1 = (short int) (MAPHEIGHT + MARGINTOP - 1);
  1128.  
  1129.         if (xSegments[k].y2 > (short int) (MAPHEIGHT + MARGINTOP - 1))
  1130.             xSegments[k].y2 = (short int) (MAPHEIGHT + MARGINTOP - 1);
  1131.     }
  1132.  
  1133.     return;
  1134. }
  1135.  
  1136. /******************************************************************************/
  1137. /*                                                                            */
  1138. /* main program                                                               */
  1139. /*                                                                            */
  1140. /******************************************************************************/
  1141.  
  1142. void main(argc,argv)
  1143.  
  1144. int  argc;
  1145. char *argv[];
  1146.  
  1147. {
  1148.     int n;
  1149.  
  1150.     initFlag = TRUE;
  1151.  
  1152.     if (argc > 1)
  1153.         verboseFlag = (!strcmp(argv[1],"-v")) ? TRUE : FALSE;
  1154.  
  1155.     sprintf(appName,"%s %s   Graphics Demo Program",sattrName,sattrVersion);
  1156.  
  1157.     if (verboseFlag)
  1158.         printf("\ninitializing toolkit for 'xdemo' ...\n");
  1159.  
  1160.     XtToolkitInitialize();
  1161.     appContext = XtCreateApplicationContext();
  1162.     theDisplay = XtOpenDisplay(appContext,NULL,appName,appName,NULL,0,
  1163.                                &argc,argv);
  1164.  
  1165.     if (!theDisplay)
  1166.     {
  1167.         printf("Error: cannot open display.\n");
  1168.         exit(-1);
  1169.     }
  1170.  
  1171.     theScreen = DefaultScreen(theDisplay);
  1172.     numColors = XDisplayCells(theDisplay,theScreen);
  1173.  
  1174.     if (verboseFlag)
  1175.         printf("creating toplevel and frame ...\n");
  1176.  
  1177.     toplevel = XtAppCreateShell(appName,appName,
  1178.                    applicationShellWidgetClass,theDisplay,NULL,0);
  1179.  
  1180.     if (verboseFlag)
  1181.         printf("creating colors ...\n");
  1182.  
  1183.     CreateColors();
  1184.  
  1185.     if (MAPTYPE == 1)                                             /* fill map */
  1186.     {
  1187.         foregroundPixel = greenPixel;
  1188.         backgroundPixel = oceanBluePixel;
  1189.     }
  1190.  
  1191.     else                                                          /* line map */
  1192.     {
  1193.         foregroundPixel = lightGreenPixel;
  1194.         backgroundPixel = nightBluePixel;
  1195.     }
  1196.  
  1197.     if (verboseFlag)
  1198.         printf("map size: %dx%d pixels, %.0fx%.0f deg\n",
  1199.             MAPWIDTH,MAPHEIGHT,MAPWIDTHD,MAPHEIGHTD);
  1200.  
  1201.     n = 0;
  1202.     XtSetArg(warg[n],XtNwidth,WINWIDTH); n++;
  1203.     XtSetArg(warg[n],XtNheight,WINHEIGHT); n++;
  1204.     XtSetArg(warg[n],XtNbackground,blackPixel); n++;
  1205.     frame = XtCreateManagedWidget("frame",widgetClass,toplevel,warg,n);
  1206.  
  1207.     /* data */
  1208.  
  1209.     secCount     =       0;
  1210.  
  1211.     gndLtd       =    -7.3;                                   /* Diego Garcia */
  1212.     gndLng       =   -72.4;
  1213.     sprintf(gndName,"%s","DGS");
  1214.  
  1215.     sunLtd       =    -15.0;                                  /* Sun position */
  1216.     sunLng       =     20.0;
  1217.     sunHgt       = EARTHSMA;
  1218.  
  1219.     ctyLtd       =   -27.0;                                  /* Easter Island */
  1220.     ctyLng       =   109.0;
  1221.  
  1222.     satLng0      =   147.5;                              /* ground track data */
  1223.     satLngAdd    =     1.0;
  1224.     satLngFact   =    -1.0;
  1225.     inc          =    51.0;
  1226.     phiFact      =    67.5;
  1227.  
  1228.     separation   =   -22.0;                   /* initial separation STS - Mir */
  1229.     sepStep      =     0.5;
  1230.  
  1231.     satLtd       =     0.0;                     /* initial satellite position */
  1232.     satLng       = satLng0;
  1233.     satHgt       =   410.0;
  1234.  
  1235.     maxSecs      = (int) (3.0 * 360.0 / satLngAdd + ONEPPM);
  1236.  
  1237.     if (verboseFlag)
  1238.         printf("calculating grid and ground station ...\n");
  1239.  
  1240.     CalcGrid();
  1241.  
  1242.     if (verboseFlag)
  1243.         printf("calculating ground track ...\n");
  1244.  
  1245.     CalcGroundTrack();
  1246.  
  1247.     CalcMapLocation(gndLtd,gndLng,&gndLocX,&gndLocY);
  1248.     CalcMapLocation(satLtd,satLng,&satLocX,&satLocY);
  1249.     CalcMapLocation(sunLtd,sunLng,&sunLocX,&sunLocY);
  1250.  
  1251.     if (verboseFlag)
  1252.         printf("calculating visibility circles ...\n");
  1253.  
  1254.     CalcVisibCircle(&visibCircleGndPix[0],gndLtd,gndLng,satHgt);
  1255.     CalcVisibCircle(&visibCircleSatPix[0],satLtd,satLng,satHgt);
  1256.     CalcVisibCircle(&visibCircleSunPix[0],sunLtd,sunLng,sunHgt);
  1257.  
  1258.     if (verboseFlag)
  1259.         printf("realizing top level ...\n");
  1260.  
  1261.     XtRealizeWidget(toplevel);
  1262.  
  1263.     if (verboseFlag)
  1264.         printf("creating graphics context ...\n");
  1265.  
  1266.     theWindow = XtWindow(toplevel);
  1267.     theGC     = XCreateGC(theDisplay,theWindow,0,0);
  1268.     drawable  = XtWindow(frame);
  1269.  
  1270.     if (verboseFlag)
  1271.         printf("programming event handlers ...\n");
  1272.  
  1273.     redrawFlag   = TRUE;
  1274.     daylightFlag = TRUE;
  1275.  
  1276.     XtAddEventHandler(frame,ButtonPressMask,FALSE,Quit,NULL);
  1277.     XtAddEventHandler(frame,StructureNotifyMask,FALSE,ResizeMap,NULL);
  1278.     XtAddEventHandler(frame,ExposureMask,FALSE,RedrawMap,NULL);
  1279.  
  1280.     XMapRaised(theDisplay,(Drawable) drawable);
  1281.  
  1282.     if (verboseFlag)
  1283.         printf("starting timer ...\n");
  1284.  
  1285.     timeInterval = 100L;
  1286.     XtAppAddTimeOut(appContext,timeInterval,TimeLoop,0);
  1287.  
  1288.     if (verboseFlag)
  1289.     {
  1290.         printf("entering application main loop ...\n");
  1291.         printf("\n");
  1292.         printf("to quit hit mouse button while cursor is inside graphics ");
  1293.         printf("window\n");
  1294.         printf("\n");
  1295.     }
  1296.  
  1297.     XtAppMainLoop(appContext);
  1298. }
  1299.  
  1300. /******************************************************************************/
  1301. /*                                                                            */
  1302. /* End of program xdemo.c                                                     */
  1303. /*                                                                            */
  1304. /******************************************************************************/
  1305.